# -*- coding: utf-8 -*-
from pymunk.vec2d import Vec2d
from pyglet.window import mouse

BUTTON_LEFT = 0
BUTTON_MIDDLE = 1
BUTTON_RIGHT = 2

BUTTON_RELEASED = 0
BUTTON_PRESSED = 1
BUTTON_HOLD = 2

class cMouse(object):

    """
     Clase encargada de gestionar el estado del raton. Ya que el raton se actualiza
     de una forma diferente al teclado (eventos, no podemos preguntar por el estado
     del dispositivo como hacemos con el teclado) tiene varios metodos dedicados a
     actualizar el raton a traves de los diferentes eventos que genera su
     utilizacion.

    :version:
    :author:
    """

    """ ATTRIBUTES

     Diccionario con el estado de los botones en la actualizacion anterior.

    last_pressed  (public)

     Diccionario con el estado de los botones en esta actualizacion.

    current_pressed  (public)

     Delta de la rueda del raton en la ultima actualizacion.

    last_wheel  (public)

     Delta de la rueda del raton en esta actualizacion.

    current_wheel  (public)

     Posicion del raton con respecto a la pantalla del motor.

    position  (public)

    """

    def get_pressed(self, button):
        """
         Obtiene el estado de un boton del raton.

        @param cMouse self : 
        @param MouseButtons button : Boton del raton del que se quiere comprobar el estado.
        @return KeyButtonState :
        @author
        """
        if self.current_pressed[button]:
            return int(self.current_pressed[button]) + int(self.last_pressed[button])
        else:
            return 0

    def get_scroll(self):
        """
         Obtiene el delta del movimiento de la rueda del raton con respecto a la ultima
         actualizacion.

        @param cMouse self : 
        @return int :
        @author
        """
        return self.current_wheel_scroll - self.last_wheel_scroll

    def update_position(self, delta):
        """
         Actualiza la posicion del raton utilizando el movimiento que este ha realizado
         desde la ultima actualizacion.

        @param cMouse self : 
        @param tuple delta : Tupla con la diferencia de posicion en los ejes x,y con respecto a la ultima actualizacion.
        @return  :
        @author
        """
        self.position += delta

    def update_buttons(self, buttons):
        """
         Actualiza el estado de los botones del raton.

        @param cMouse self : 
        @param dict buttons : Diccionation con los botones del raton y los estado actuales de cada uno de ellos.
        @return  :
        @author
        """
        self.current_pressed = [bool(buttons & mouse.LEFT),\
                                bool(buttons & mouse.MIDDLE),\
                                bool(buttons & mouse.RIGHT)]

    def update_button_state(self, button, state):
        """
         Actualiza el estado actual de un boton del raton.

        @param cMouse self : 
        @param MouseButtons button : Boton del raton que estamos actualizando.
        @param KeyButtonState state : Estado del boton a actualizar.
        @return  :
        @author
        """
        self.current_pressed[button/2] = state

    def update_wheel(self, delta):
        """
         Actualiza la informacion sobre el movimiento de la rueda del raton.

        @param cMouse self : 
        @param tuple delta : Tupla con la diferencia en los ejec x,y con la diferencia de posicion de la rueda del raton con respecto a la actualizacion anterior.
        @return  :
        @author
        """
        self.current_wheel_scroll += delta

    def update(self):
        """
         Actualiza la informacion de raton, de forma que los botones pulsados pasen a ser
         los botones pulsados en la actualizacion anterior, y el delta de la rueda del
         raton pase a ser el delta anterior de la rueda del raton.

        @param cMouse self : 
        @return  :
        @author
        """
        self.last_pressed = self.current_pressed
        self.last_wheel_scroll = self.current_wheel_scroll
        self.current_wheel_scroll = 0

    def __init__(self):
        self.last_pressed = [False, False, False]
        self.current_pressed = [False, False, False]
        self.position = Vec2d(0,0) 
        self.current_wheel_scroll = 0
        self.last_wheel_scroll = 0

